{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-06T02:54:27.873267Z",
     "start_time": "2025-03-06T02:54:22.599574Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.3.1+cu121\n",
      "cuda:0\n"
     ]
    }
   ],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:54:35.158862Z",
     "start_time": "2025-03-06T02:54:33.517014Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Path: 用于处理文件路径。\n",
    "from pathlib import Path\n",
    "\n",
    "# 定义数据集的根目录为 ./cifar-10/\n",
    "# 使用 Path 对象处理文件路径\n",
    "DATA_DIR = Path(\"./cifar-10\")\n",
    "\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"  # 训练集标签csv文件\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\"  #测试集模板csv文件\n",
    "train_folder = DATA_DIR / \"train\"  # 训练集图片文件夹\n",
    "test_folder = DATA_DIR / \"test\"  # 测试集图片文件夹\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "\n",
    "# 定义一个函数 parse_csv_file，用于解析 CSV 文件并返回图像路径和标签的列表\n",
    "# filepath: CSV 文件的路径。\n",
    "# folder: 图像文件夹的路径\n",
    "# 读取 CSV 文件，解析每一行，生成图像路径和标签的元组列表\n",
    "def parse_csv_file(filepath, folder):\n",
    "    # 初始化一个空列表 results，用于存储解析结果\n",
    "    # 使用列表存储图像路径和标签的元组,方便后续访问和操作解析结果\n",
    "    results = []\n",
    "\n",
    "    # 打开 CSV 文件，读取所有行并跳过第一行（表头）\n",
    "    # 使用 open 函数打开文件，readlines() 读取所有行，[1:] 跳过表头\n",
    "    with open(filepath, 'r') as f:\n",
    "        lines = f.readlines()[1:]\n",
    "\n",
    "    # 遍历每一行数据，去除换行符并按逗号分隔，得到图像 ID 和标签\n",
    "    # 使用 strip('\\n') 去除换行符，split(',') 按逗号分隔,提取图像 ID 和标签\n",
    "    for line in lines:\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "\n",
    "        # 拼接图像文件的完整路径\n",
    "        # 使用 Path 对象拼接路径，f\"{image_id}.png\" 生成图像文件名\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "\n",
    "        # 将图像路径和标签的元组添加到 results 列表中\n",
    "        results.append((image_full_path, label_str))\n",
    "    return results\n",
    "\n",
    "\n",
    "#  调用 parse_csv_file 函数，解析训练集和测试集的 CSV 文件\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "\n"
   ],
   "id": "bf2f1184bf5306f9",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 数据准备",
   "id": "8dd20bd27b42a2ef"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:54:50.031700Z",
     "start_time": "2025-03-06T02:54:48.469534Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Path: 用于处理文件路径。\n",
    "from pathlib import Path\n",
    "\n",
    "# 定义数据集的根目录为 ./cifar-10/\n",
    "# 使用 Path 对象处理文件路径\n",
    "DATA_DIR = Path(\"./cifar-10\")\n",
    "\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"  # 训练集标签csv文件\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\"  #测试集模板csv文件\n",
    "train_folder = DATA_DIR / \"train\"  # 训练集图片文件夹\n",
    "test_folder = DATA_DIR / \"test\"  # 测试集图片文件夹\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "\n",
    "# 定义一个函数 parse_csv_file，用于解析 CSV 文件并返回图像路径和标签的列表\n",
    "# filepath: CSV 文件的路径。\n",
    "# folder: 图像文件夹的路径\n",
    "# 读取 CSV 文件，解析每一行，生成图像路径和标签的元组列表\n",
    "def parse_csv_file(filepath, folder):\n",
    "    # 初始化一个空列表 results，用于存储解析结果\n",
    "    # 使用列表存储图像路径和标签的元组,方便后续访问和操作解析结果\n",
    "    results = []\n",
    "\n",
    "    # 打开 CSV 文件，读取所有行并跳过第一行（表头）\n",
    "    # 使用 open 函数打开文件，readlines() 读取所有行，[1:] 跳过表头\n",
    "    with open(filepath, 'r') as f:\n",
    "        lines = f.readlines()[1:]\n",
    "\n",
    "    # 遍历每一行数据，去除换行符并按逗号分隔，得到图像 ID 和标签\n",
    "    # 使用 strip('\\n') 去除换行符，split(',') 按逗号分隔,提取图像 ID 和标签\n",
    "    for line in lines:\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "\n",
    "        # 拼接图像文件的完整路径\n",
    "        # 使用 Path 对象拼接路径，f\"{image_id}.png\" 生成图像文件名\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "\n",
    "        # 将图像路径和标签的元组添加到 results 列表中\n",
    "        results.append((image_full_path, label_str))\n",
    "    return results\n",
    "\n",
    "\n",
    "#  调用 parse_csv_file 函数，解析训练集和测试集的 CSV 文件\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)"
   ],
   "id": "16e06049316438cf",
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T02:55:01.271794Z",
     "start_time": "2025-03-06T02:55:01.224253Z"
    }
   },
   "cell_type": "code",
   "source": [
    "train_df = pd.DataFrame(train_labels_info[0:45000])  # 取前45000张图片作为训练集\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])  # 取后5000张图片作为验证集\n",
    "test_df = pd.DataFrame(test_csv_info)  # 取测试集\n",
    "\n",
    "train_df.columns = ['filepath', 'class']  # 给数据框添加列名\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']  # 数据准备"
   ],
   "id": "4fa7dfde0299585b",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:01:39.982238Z",
     "start_time": "2025-03-06T03:01:39.972494Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# PIL（Python Imaging Library）用于图像处理，Image 模块可以加载和操作图像\n",
    "from PIL import Image\n",
    "\n",
    "# Dataset 是 PyTorch 中用于定义数据集的基类\n",
    "# DataLoader 用于批量加载数据，支持多线程和数据打乱\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "# transforms 提供了图像预处理和数据增强的工具，如调整大小、旋转、归一化等\n",
    "from torchvision import transforms\n",
    "\n",
    "\n",
    "# 定义一个自定义数据集类，继承自 PyTorch 的 Dataset 类\n",
    "# CIFAR-10 数据集的加载方式与默认数据集不同，需要自定义\n",
    "class Cifar10Dataset(Dataset):\n",
    "    # 定义一个字典，将数据集模式（train/eval/test）映射到对应的数据框\n",
    "    # 通过 mode 参数快速获取对应的数据集\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "\n",
    "    # 创建一个字典，将类别名称映射到索引（如 \"cat\" -> 0）\n",
    "    # 使用字典推导式生成映射关系\n",
    "    # 模型需要数值标签，而数据通常以类别名称存储，因此需要转换\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)}\n",
    "\n",
    "    # 创建一个字典，将索引映射回类别名称（如 0 -> \"cat\"）\n",
    "    # 与 label_to_idx 类似，但方向相反\n",
    "    # 在模型预测后，可能需要将索引转换回类别名称以便解释结果\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}\n",
    "\n",
    "    # 初始化 Cifar10Dataset 类的实例\n",
    "    # mode：指定数据集模式（train/eval/test）。\n",
    "    # transform：指定图像预处理和数据增强的方法\n",
    "    def __init__(self, mode, transform=None):\n",
    "        # 根据 mode 获取对应的数据框\n",
    "        # 使用字典的 get 方法获取值，如果 mode 不存在则返回 None\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "\n",
    "        # 检查 mode 是否有效，如果无效则抛出错误\n",
    "        # 防止因无效模式导致后续代码出错\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        # 保存 transform 参数到对象属性中\n",
    "        # 在 __getitem__ 方法中会用到 transform\n",
    "        self.transform = transform\n",
    "\n",
    "    # 根据索引获取单个样本（图像和标签）\n",
    "    # Dataset 类的核心方法，定义了如何获取数据,DataLoader 会调用此方法批量加载数据\n",
    "    def __getitem__(self, index):\n",
    "        # 从数据框中获取图像路径和标签\n",
    "        # 使用 iloc 方法按索引获取数据,数据框存储了图像路径和标签，需要按索引提取\n",
    "        img_path, label = self.df.iloc[index]\n",
    "\n",
    "        # 加载图像并转换为 RGB 格式\n",
    "        # Image.open 加载图像，convert('RGB') 确保图像为三通道\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "\n",
    "        # 对图像应用预处理和数据增强\n",
    "        img = self.transform(img)\n",
    "\n",
    "        # 将类别名称转换为索引,使用 label_to_idx 字典进行转换\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        # 返回数据框的行数，即样本数量\n",
    "        # shape[0] 获取数据框的行数\n",
    "        return self.df.shape[0]\n",
    "\n",
    "\n",
    "# 定义图像的输入大小\n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4368, 0.4268, 0.3947], [0.2464, 0.2418, 0.2358]\n",
    "\n",
    "# 定义训练数据的预处理和数据增强方法\n",
    "# 数据增强（如旋转、翻转）可以提高模型的泛化能力，避免过拟合\n",
    "# 训练时需要增加数据的多样性，同时确保输入数据符合模型的期望格式\n",
    "transforms_train = transforms.Compose([\n",
    "    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),  # 将图像调整为指定大小（32x32）\n",
    "    transforms.RandomRotation(40),  # 随机旋转图像，最大角度为40度\n",
    "    transforms.RandomHorizontalFlip(),  # 随机水平翻转图像\n",
    "    transforms.ToTensor(),  # 将图像转换为PyTorch张量（Tensor），并将像素值从 [0, 255] 归一化到 [0, 1]。\n",
    "    transforms.Normalize(mean, std)  # 根据均值和标准差对图像进行归一化\n",
    "])\n",
    "\n",
    "# 验证/测试数据不需要数据增强，只需进行基本的预处理\n",
    "# 验证/测试时，需要保持数据的原始分布，以评估模型的真实性能\n",
    "transforms_eval = transforms.Compose([\n",
    "    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),  # 将图像调整为指定大小（32x32）\n",
    "    transforms.ToTensor(),  # 将图像转换为PyTorch张量（Tensor），并将像素值从 [0, 255] 归一化到 [0, 1]。\n",
    "    transforms.Normalize(mean, std)  # 根据均值和标准差对图像进行归一化\n",
    "])\n",
    "\n",
    "# 创建训练数据集对象\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval)"
   ],
   "id": "cf00d128613d16ac",
   "outputs": [],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:01:41.950609Z",
     "start_time": "2025-03-06T03:01:41.946608Z"
    }
   },
   "cell_type": "code",
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True)\n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False)"
   ],
   "id": "abdaaa9277c8150e",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型定义",
   "id": "52499d2569cf1507"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:03:06.663724Z",
     "start_time": "2025-03-06T03:03:06.658056Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=128, out_channels=128, kernel_size=3, padding=\"same\"),\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Flatten(),\n",
    "        )\n",
    "\n",
    "        self.cls = nn.Linear(2048, num_classes)\n",
    "\n",
    "        self.init_weights()\n",
    "\n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "\n",
    "    @classmethod\n",
    "    def from_pretrained(cls, ckpt_path, num_classes=10):\n",
    "        \"\"\"\n",
    "        从预训练的模型中加载权重，并实例化一个新的模型。\n",
    "        预训练模型的权重包括：模型的结构（VGG）、模型的权重（.pth文件）、模型的类别数（num_classes）\n",
    "        :param ckpt_path: 预训练模型的权重路径\n",
    "        :param num_classes: 预训练模型的类别数\n",
    "        \"\"\"\n",
    "        state_dict = torch.load(ckpt_path, map_location=\"cpu\")  #加载模型\n",
    "        state_dict.pop(\"cls.weight\")  #去掉最后一层的权重\n",
    "        state_dict.pop(\"cls.bias\")  #去掉最后一层的偏置\n",
    "\n",
    "        model = cls(num_classes=num_classes)  #实例化模型\n",
    "        # 将修改后的状态字典加载到新创建的模型实例中。参数strict=False表示在加载状态字典时，如果字典中存在模型不期望的键或缺少某些期望的键，将不会抛出错误。\n",
    "        # 这在迁移学习中很有用，因为可能希望覆盖或忽略一些权重。\n",
    "        model.load_state_dict(state_dict, strict=False)  #加载模型参数\n",
    "\n",
    "        return model\n",
    "\n",
    "    def forward(self, x):\n",
    "        features = self.model(x)\n",
    "        return self.cls(features)"
   ],
   "id": "1a2cb160b8ec6f44",
   "outputs": [],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:03:07.793307Z",
     "start_time": "2025-03-06T03:03:07.786481Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = VGG(len(class_names))\n",
    "print(type(model.named_parameters()))\n",
    "for key, value in model.named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")"
   ],
   "id": "cf39c08fa0481640",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 18432\n",
      "              model.5.bias              paramerters num: 64\n",
      "             model.7.weight             paramerters num: 36864\n",
      "              model.7.bias              paramerters num: 64\n",
      "            model.10.weight             paramerters num: 73728\n",
      "             model.10.bias              paramerters num: 128\n",
      "            model.12.weight             paramerters num: 147456\n",
      "             model.12.bias              paramerters num: 128\n",
      "               cls.weight               paramerters num: 20480\n",
      "                cls.bias                paramerters num: 10\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型训练",
   "id": "6960e6e636bfd0fb"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:04:08.215266Z",
     "start_time": "2025-03-06T03:04:08.211037Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        preds = logits.argmax(axis=-1)  # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ],
   "id": "f34627ea86b78ff0",
   "outputs": [],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:04:14.123407Z",
     "start_time": "2025-03-06T03:04:14.118893Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "\n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ],
   "id": "d6d426086e6afff8",
   "outputs": [],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:04:18.842523Z",
     "start_time": "2025-03-06T03:04:18.837319Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else:\n",
    "            self.counter += 1\n",
    "\n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "be9a3086ca3c19f1",
   "outputs": [],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:04:55.399336Z",
     "start_time": "2025-03-06T03:04:55.393513Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 训练\n",
    "def training(\n",
    "        model,\n",
    "        train_loader,\n",
    "        val_loader,\n",
    "        epoch,\n",
    "        loss_fct,\n",
    "        optimizer,\n",
    "        save_ckpt_callback=None,\n",
    "        early_stop_callback=None,\n",
    "        eval_step=500,\n",
    "):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "\n",
    "                    # 1. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 2. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "\n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict\n"
   ],
   "id": "16b51c2ff0c33bd1",
   "outputs": [],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:12:12.080738Z",
     "start_time": "2025-03-06T03:05:17.844554Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch = 10\n",
    "# model = VGG(num_classes=10)  #第一次先训练，得到下面best.ckpt后，再注释这一条，用下面的加载模型\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "# Optimizers specified in the torch.optim package\n",
    "\n",
    "exp_name = \"vgg-fine-tune\"\n",
    "\n",
    "# 1. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "\n",
    "save_ckpt_callback = SaveCheckpointsCallback(f\"checkpoints/{exp_name}\", save_step=len(train_dl), save_best_only=True)\n",
    "# 2. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    eval_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "id": "4893e1635ded9266",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/7040 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "b937d326db024949bf79a4ee3c797d6d"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:12:12.256590Z",
     "start_time": "2025-03-06T03:12:12.084243Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ],
   "id": "f21e1d15b0220a8e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 模型评估",
   "id": "a3d8dac62b8d52d2"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:12:15.248804Z",
     "start_time": "2025-03-06T03:12:12.257595Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(f\"checkpoints/{exp_name}/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "5ef5707316555a3",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.6879\n",
      "accuracy: 0.7698\n"
     ]
    }
   ],
   "execution_count": 25
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:33:50.569979Z",
     "start_time": "2025-03-06T03:12:25.847014Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = VGG.from_pretrained(\"checkpoints/vgg-fine-tune/best.ckpt\", num_classes=10)\n",
    "# 微调（Fine-tuning）：在迁移学习或微调预训练模型时，这种方法特别有用。在这种情况下，你可能希望对模型的预训练部分（不包含\"cls\"的部分）使用较小的学习率，以避免破坏已经学到的特征。而对新添加的或需要特别训练的部分（如新的分类层，包含\"cls\"的部分）使用较高的学习率，以便更快地学习到特定任务的特征。\n",
    "optimizer = torch.optim.Adam(\n",
    "    [\n",
    "        {\n",
    "            \"params\": [value for key, value in model.named_parameters() if \"cls\" not in key],\n",
    "            \"lr\": 0.0001  #卷积层用的是之前的预训练参数，不希望变化过大，所以学习率设为较小\n",
    "        },\n",
    "        {\n",
    "            \"params\": [value for key, value in model.named_parameters() if \"cls\" in key],\n",
    "            \"lr\": 0.0005  #分类层是重新初始化的，可以用较大的学习率\n",
    "        },\n",
    "    ]\n",
    ")\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model,\n",
    "    train_dl,\n",
    "    eval_dl,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    ")"
   ],
   "id": "dcb343d238a078b5",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/7040 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "41aa8437e19548dd9350c147433bee07"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 26
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-06T03:34:01.156904Z",
     "start_time": "2025-03-06T03:33:50.572820Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model.load_state_dict(torch.load(f\"checkpoints/{exp_name}/best.ckpt\", map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ],
   "id": "987d3a866b58c2d7",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.5684\n",
      "accuracy: 0.8090\n"
     ]
    }
   ],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "c3b2e6616670ea0e"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
